In a code division multiple access (CDMA) cellular telephone system, the different forward and reverse link transmitter waveforms are modulated by unique pseudorandom noise (PN) code sequences that provide identification of the base stations for the forward link and identification of the mobile stations for the reverse link. The PN code sequence that is uniquely assigned to a transmitter (base station or mobile station) is a different phase shift (offset) of a reference sequence, as illustrated in FIG. 1 (numeral 100). In FIG. 1, each of the base stations (denoted as having offsets A, B, C, D, E, F, and G) transmits signals modulated by PN code 1 with a unique assigned offset, and each mobile station (denoted as having offsets a, b, c, . . . , q, r) transmits signals modulated by PN code 2 with a unique assigned offset. The present invention discloses a method of generating these unique assigned offsets of any PN code relative to a given reference sequence.
It is well known in the literature, as in CDAM Systems Engineering Handbook, that periodic binary PN sequences are generated using linear feedback shift registers (LFSRs). There are two basic LFSR configurations: the xe2x80x9csimple shift register generatorxe2x80x9d (SSRG) and the xe2x80x9cmodular shift register generatorxe2x80x9d (MSRG). Diagrams of these two LFSR configurations for n-stage shift registers are shown as 201 and 301 in FIGS. 2 and 3, respectively, in which the coefficients {ci, i=1, 2, . . . , nxe2x88x921} assume, values 0 or 1 and indicate the feedback connections necessary for each configuration to produce at the output of the LFSR (203 or 303) some shift of the sequence described by the PN sequence-generating characteristic polynomial
f(x)=1+c1x+c2x2+c3x3+ . . . +cnxe2x88x921xnxe2x88x921+xn, ci=0 or 1xe2x80x83xe2x80x83(1a)
where, as described in the book Shift Register Sequences, the polynomial represents the recursion or the successive 0 or 1 valued outputs of the register, {ak}, given by
ak=c1akxe2x88x921+c2akxe2x88x922+ . . . +cnxe2x88x921akxe2x88x92n+1+akxe2x88x92n, ci=0 or 1xe2x80x83xe2x80x83(1b)
The output sequence from the LFSR can be denoted a0, a1, a2, . . . , and this sequence can be represented as a polynomial, a(x), that is,
a0, a1, a2, . . . ⇄a(x)=a0+a1x+a2x+ . . . xe2x80x83xe2x80x83(1c)
It is also described in CDMA Systems Engineering Handbook, that the power series for output sequence a(x) is obtained by dividing a binary polynomial, g(x), of degree less than n, by the characteristic polynomial, f(x), of degree n:             a      ⁢              (        x        )              =                  g        ⁢                  (          x          )                            f        ⁢                  (          x          )                      ,xe2x80x83g(x)=g0+g1x+g2x2+ . . . +gnxe2x88x921xnxe2x88x921, gi=0 or 1xe2x80x83xe2x80x83(1d)
Excluding the case of g(x)=0, there are 2nxe2x88x921 possible numerator polynomials of degree less than n. For a PN sequence, which has period P=2nxe2x88x921, each of the possible numerator polynomials corresponds uniquely to one of the possible xe2x80x9cphase shiftsxe2x80x9d for the periodic sequence, and each one corresponds uniquely to one of the nonzero initial loadings of the LFSR. The terms of the sequence a(x) can be calculated by xe2x80x9clong division,xe2x80x9d given g(x). When the numerator polynomial is g(x)=1, the resulting sequence of 1/f(x) is the reference sequence for the PN code. The phase shifts of the PN sequence are measured with respect to this reference sequence.
For example, let the characteristic polynomial of a PN sequence be f(x)=1+x+x3 and consider two cases of the numerator polynomial, g(x)=1+x and g(x)=1. By long division for case of g(x)=1+x we find that                                           a            ⁡                          (              x              )                                =                                                    1                +                x                                            1                +                x                +                                  x                  3                                                      =                                          1                +                                  x                  3                                +                                  x                  4                                +                                  x                  5                                +                                  x                  7                                +                                  x                  10                                +                                  x                  11                                +                                                      x                    12                                    ⁢                  …                                            →                              (                                  1                  ,                  0                  ,                  0                  ,                  1                  ,                  1                  ,                  1                  ,                  0                                )                                                    ,                  (                      1            ,            0            ,            0            ,            1            ,            1            ,            1            ,            0                    )                ,                  (                      1            ,            1            ,            1            ,            0            ,            1            ,            0            ,            0                    )                ,                  (                      1            ,            0            ,            …                    )                ,        …                            (1e)            
in which the parentheses are used to indicate periods of the sequence having P=2nxe2x88x921=7 bits since n=3. For the case of g(x)=1, the long division becomes the reference sequence:                                           a            ⁡                          (              x              )                                =                                    1                              1                +                x                +                                  x                  3                                                      =                                          1                +                x                +                                  x                  2                                +                                  x                  4                                +                                  x                  7                                +                                  x                  8                                +                                  x                  9                                +                                                      x                    11                                    ⁢                  …                                            →                              (                                  1                  ,                  1                  ,                  1                  ,                  0                  ,                  1                  ,                  0                  ,                  0                                )                                                    ,                  (                      1            ,            1            ,            …                    )                ,        …                            (1f)            
In this example, the sequence for numerator polynomial g(x)=1+x is shifted three bits to the right compared to the reference sequence. The number of bits shifted is predicted from g(x) when it is expressed as a power of x, reduced to a polynomial of degree less than n by the modular calculation, denoted xe2x80x9cmodulo f(x)xe2x80x9d (or sometimes xe2x80x9cmod f(x)xe2x80x9d for short) given by
g(x)=x3 modulo f(x)=x3 modulo (1+x+x3)=1+xxe2x80x83xe2x80x83(2a)
The power of x in the expression x3 modulo f(x) denotes the number of bits being shifted relative to the reference sequence of 1/f(x). It is now established that a given sequence can always be represented by either a power of x or by a polynomial.
The initial state of the shift register contents in FIGS. 2 and 3 is denoted by the vector (R1, R2, . . . , Rn), which is also represented as the polynomial s0(x), as follows:
(R1, R2, . . . , Rn)⇄s0(x)=R1+R2x+R3x2+ . . . +Rnxnxe2x88x921, Ri=0 or 1xe2x80x83xe2x80x83(2b)
Implied but not shown in FIGS. 2 and 3 are connections for various timing and control signals, such as the clock pulses that control the advancement of the LFSR""s shift register.
Elements 202 and 302 of FIGS. 2 and 3 show the outputs of the shift register stages being selectively modulo-2 added in the phase shift networks (PSNs), with the selection determined by the xe2x80x9cmaskxe2x80x9d vector (m0, m1, . . . , mnxe2x88x921), where each component takes the values 0 or 1. As described in Shift Register Sequences, the bit-by-bit modulo-2 addition of two or more sequences that are different shifts of a PN sequence produces another shift of the sequence at the output of the PSN (204 or 304).
The prior art regarding PN code masks includes U.S. Pat. Nos. 4,460,992; 5,103,459; 5,416,797; and 5,737,329 which describe means which are disclosed for implementing CDMA communications systems in which transmissions to or from several mobile receivers are multiplexed using PN codes that are shifts of the same PN code sequence. In these patents, the shifts are obtained using masks. However, these patents do not describe how the masks are calculated. U.S. Pat. Nos. 5,228,054 and 5,532,695 describe means for making PN code masks work in conjunction with the lengthening of the sequence by insertion, but also do not indicate how the masks are calculated and implemented. In the system disclosed in U.S. Pat. No. 5,034,906, delayed PN sequences are obtained by timing techniques rather than masks. In the system disclosed in U.S. Pat. No. 5,519,736, a master PN sequence generated by an MSRG is modified by feed-forward circuits and stored masks to produce N modified versions of the master PN sequence for CDMA multiplexing, but the method for determining the masks and the feed-forward circuit connections is not disclosed.
The relationship between the sequence at the input of an SSRG and the sequence at the output of a PSN for a special LFSR loading was recognized in a paper by W. A. Davis, entitled xe2x80x9cAutomatic delay changing facility for delayed m-sequencesxe2x80x9d (Proc. IEEE, June 1966), which suggested using an MSRG to calculate the mask for the special case of the loading. Also, in the book Direct Sequence Spread Spectrum Techniques, it is noted that a particular mask causes the sequence at the output of the PSN to be delayed k bits from the sequence at the input of the SSRG for any sequence shift at the input.
Regarding the algebra of PN code masks, for both the SSRG and the MSRG implementations of a PN sequence, the particular phase of the sequence at the output of the shift register (taken from the last stage) can be changed by changing the initial loading (state) of the shift register, denoted as s0(x) in (2b). By the method disclosed in this invention, however, any desired shift of the sequence can also be obtained by combining certain outputs of the shift register stages, without changing s0(x). The particular shift register stages to be combined are specified by a mask vector (m0, m1, . . . , mnxe2x88x921), which is also represented by a mask polynomial as
m(x)=m0+m1x+ . . . +mnxe2x88x921xnxe2x88x921, mi=0 or 1xe2x80x83xe2x80x83(3).
Those output stages that are modulo-2 added at the PSN are specified by the nonzero mask vector components. This control is implemented in logic circuitry by AND gating each mask vector component with its corresponding shift register stage.
The present invention discloses a method and program for determining the PN generator mask which is required to obtain a specific shift of the PN sequence at the output of a phase shift network (PSN), relative to a reference sequence, for either a simple shift register generator (SSRG) or a modular shift register generator (MSRG) under any nonzero initial loading of the respective n-stage linear feedback shift register (LFSR).
By the method that is disclosed in this invention, the specific mask vector is found for any value of the initial loading of the LFSR, whether it is an SSRG or it is an MSRG, each type of LFSR requiring a different procedure.
For any nonzero initial loading of the LFSR, the output of the shift register will be some shift (for example, the qth shift) relative to the reference sequence 1/f(x), as illustrated in FIG. 4 (numeral 400). The algebra for describing such an output sequence is given by aq(x)=[xq modulo f(x)]/f(x). The present invention discloses the procedure to determine the vector of mask coefficients (m0, m1, . . . , mnxe2x88x921) that produces the desired kth shift at the output of the PSN relative to the reference sequence 1/f(x). The method is stated first for the SSRG, then for the MSRG.
The mask polynomial, being a polynomial of degree less than n, can be written as a power of x modulo the characteristic polynomial, as established in (2a):
m(x)=m0+m1x+ . . . +mnxe2x88x921xnxe2x88x921=xr modulo f(x)xe2x80x83xe2x80x83(4).
Assuming that the mask polynomial is xr modulo f(x), and that the initial loading of the shift register is such that the SSRG output is                               a          q                =                              (            x            )                    =                                                                      g                  q                                ⁡                                  (                  x                  )                                                            f                ⁡                                  (                  x                  )                                                      =                                                            x                  q                                ⁢                mod                ⁢                                  xe2x80x83                                ⁢                                  f                  ⁡                                      (                    x                    )                                                                              f                ⁡                                  (                  x                  )                                                                                        (        5        )            
then the output of the PSN, which is the kth sequence shift relative to the reference sequence, 1/f(x), is given by                                           a            k                    ⁡                      (            x            )                          =                                                            x                k                            ⁢              mod              ⁢                                                xe2x80x83                                ⁢                                  xe2x80x83                                            ⁢                              f                ⁡                                  (                  x                  )                                                                    f              ⁡                              (                x                )                                              =                                                    x                                  q                  +                  r                  -                  n                  +                  1                                            ⁢              mod              ⁢                              xe2x80x83                            ⁢                              f                ⁡                                  (                  x                  )                                                                    f              ⁡                              (                x                )                                                                        (        6        )            
These SSRG and PSN outputs for any loading (R1, R2, . . . , Rn) are shown in FIG. 4, numeral 400. From (6), we have
q+rxe2x88x92n+1=kxe2x80x83xe2x80x83(7a)
where, as shown in FIG. 4, q is the shift at the SSRG output and k is the desired shift at the PSN output, both relative the reference sequence. From (7a) the required mask polynomial parameter r for (4) is
r=kxe2x88x92q+nxe2x88x921xe2x80x83xe2x80x83(7b).
Thus the general procedure for finding the SSRG mask required to generate the kth shift of the sequence at the PSN output is the following, based on a given initial loading, s0(x):
1. Find the value of q (the phase shift at the SSRG output). From (1d), the numerator polynomial gq(x) is determined from the initial state, from which q is found.
2. Calculate the SSRG mask polynomial from (4) and (7b).
Example (SSRG mask) Suppose that it is desired to generate the 10th shift of the sequence 1/f(x), for a 4-stage SSRG with f(x)=1+x+x4 (k=10 and n=4) for two different initial loadings 1000 and 1001. The application of the general procedure for the initial loading 1000 takes the following steps:
1. For the initial loading 1000, the first four bits of the sequence are 0, 0, 0, 1. Thus from (1c) we have aq(x)=x3+ . . . and
gq(x)=terms of aq(x)f(x) with degree less than 4=x3xe2x86x92q=3.
2. From (7b), the parameter for the required mask polynomial is r=kxe2x88x92q+nxe2x88x921=r=10xe2x88x923+4xe2x88x921=10. The mask polynomial is calculated as follows:                               m          ⁡                      (            x            )                          =                              x            r                    ⁢          modulo          ⁢                      xe2x80x83                    ⁢                      f            ⁡                          (              x              )                                                              =                              [                                          x                t0                            ⁢              modulo              ⁢                              xe2x80x83                            ⁢                              f                ⁡                                  (                  x                  )                                                      ]                    =                      1            +            x            +                          x              2                                          
which gives the mask vector (m0, m1, m2, m3)=(1, 1, 1, 0). This indicates that the first, second, and third stages of the SSRG are modulo-2 added at the PSN to give the required shift at the PSN output, as shown in FIG. 5, numeral 500.
The application of the general procedure for the case of the initial loading 1001 takes the following steps. This example will show that the same PSN output shift can be obtained for a different SSRG loading.
1. For the initial loading 1001, the first four bits of the sequence are 1, 0, 0, 1. Thus from (1c) we have aq(x)=1+x3+ . . . and                                           g            q                    ⁡                      (            x            )                          =                  terms          ⁢                      xe2x80x83                    ⁢          of          ⁢                      xe2x80x83                    ⁢                                    a              q                        ⁡                          (              x              )                                ⁢                      f            ⁡                          (              x              )                                ⁢                      xe2x80x83                    ⁢          with          ⁢                      xe2x80x83                    ⁢          degree          ⁢                      xe2x80x83                    ⁢          less          ⁢                      xe2x80x83                    ⁢          than          ⁢                      xe2x80x83                    ⁢          4                                        =                  1          +          x          +                      x            3                                                            =                                    x              7                        ⁢            modulo            ⁢                                          xe2x80x83                            ⁢                              xe2x80x83                                      ⁢                          f              ⁡                              (                x                )                                                    ,                              implying            ⁢                          xe2x80x83                        ⁢            that            ⁢                          xe2x80x83                        ⁢            q                    =          7                    
2. From (7b), the parameter for the required mask polynomial is r=kxe2x88x92q+nxe2x88x921=r=10xe2x88x927+4xe2x88x921=6. The mask polynomial is calculated as follows:                               m          ⁡                      (            x            )                          =                              x            r                    ⁢          modulo          ⁢                      xe2x80x83                    ⁢                      f            ⁡                          (              x              )                                                              =                              [                                          x                6                            ⁢              modulo              ⁢                              xe2x80x83                            ⁢                              f                ⁡                                  (                  x                  )                                                      ]                    =                                    x              2                        +                          x              3                                          
which gives the mask vector (m0, m1, m2, m3)=(0, 0, 1, 1). This indicates that third and fourth stages of the SSRG are modulo-2 added at the PSN, to give the required shift at the PSN output, as shown in FIG. 5.
Having calculated the two SSRG maskxe2x80x94one for the initial loading of 1000 and one for the initial loading of 1001xe2x80x94we know which stages of the respective SSRGs to be combined (modulo-2 added) to obtain the desired sequence shifts at the respective PSN outputs. The SSRG and PSN outputs are compared for this example in FIG. 5, numeral 500, to observe how the mask formulas applied in these two situations have enabled us to produce the same shift (k=10) at the outputs of the PSNs (503 and 506), although the shifts at the outputs of the SSRGs (501 and 504) are different.
Now the MSRG shift register configuration is considered. For an MSRG, the mask polynomial, being of degree less than n, can be written as the polynomial representing the first n bits of some shift, r, of the sequence:                               m          ⁡                      (            x            )                          =                                            m              0                        +                                          m                1                            ⁢              x                        +            …            +                                          m                                  n                  -                  1                                            ⁢                              x                                  n                  -                  1                                                              =                                    [                                                                    x                    r                                    ⁢                  mod                  ⁢                                      xe2x80x83                                    ⁢                                      f                    ⁡                                          (                      x                      )                                                                                        f                  ⁡                                      (                    x                    )                                                              ]                                      deg               less than               n                                                          (        8        )            
It is assumed that the initial loading of the shift register is such that the MSRG output is                                           a            q                    ⁡                      (            x            )                          =                                                            g                q                            ⁡                              (                x                )                                                    f              ⁡                              (                x                )                                              =                                                                      x                  q                                ⁢                                  xe2x80x83                                ⁢                mod                ⁢                                  xe2x80x83                                ⁢                                  f                  ⁡                                      (                    x                    )                                                                              f                ⁡                                  (                  x                  )                                                      =                                                            s                  0                  *                                ⁡                                  (                  x                  )                                                            f                ⁡                                  (                  x                  )                                                                                        (        9        )            
where s0*(x) is the reverse of the initial state polynomial. Then the output of the PSN, which is the kth sequence shift relative to the reference sequence, 1/f(x), is given by             a      k        ⁡          (      x      )        =                              x          k                ⁢        mod        ⁢                  xe2x80x83                ⁢                  f          ⁡                      (            x            )                                      f        ⁡                  (          x          )                      =                            x                      q            +            r            -            n            +            1                          ⁢        mod        ⁢                  xe2x80x83                ⁢                  f          ⁡                      (            x            )                                      f        ⁡                  (          x          )                    
These MSRG and PSN outputs for any loading (R1, R2, . . . , Rn) are shown in FIG. 6, numeral 600. From (10), it is seen that
q+rxe2x88x92n+1=kxe2x80x83xe2x80x83(11a)
where, as shown in FIG. 6, q is the shift at the MSRG output and k is the desired shift at the PSN output, both relative to the reference sequence. From (11a) the required mask polynomial parameter r for (8) is
r=kxe2x88x92q+nxe2x88x921xe2x80x83xe2x80x83(11b).
Thus the general procedure for finding the MSRG mask required to generate the kth shift of the sequence at the output of the PSN is the following, based on a given initial loading s0(x):
1. Find the value of q (the phase shift at the MSRG output). From (9), the numerator polynomial gq(x) is determined as the reverse of the initial state, from which q is found.
2. Calculate the MSRG mask polynomial from (8) and (11b).
As an example regarding the MSRG mask, it is supposed that it is desired to generate the 10th shift of the sequence 1/f(x), for a 4-stage MSRG with f(x)=1+x+x4 (k=10 and n=4) for two different initial loadings, 1000 and 1001. The application of the general procedure for the initial loading 1000 takes the following steps:
1. For the initial loading 1000, the initial state polynomial is s0(x)=1. From (9) the numerator polynomial gq(x) is the reverse of s0(x), or gq(x)=x3. Thus q=3.
2. From (11b), the parameter for the required mask polynomial is r=kxe2x88x92q+nxe2x88x921=10xe2x88x923+4xe2x88x921=10. The MSRG mask polynomial is calculated as       m    ⁡          (      x      )        =                    {                                            x              r                        ⁢            mod            ⁢                          xe2x80x83                        ⁢                          f              ⁡                              (                x                )                                                          f            ⁡                          (              x              )                                      }                    deg         less than         n              =                  {                                            x              10                        ⁢            mod            ⁢                          xe2x80x83                        ⁢                          f              ⁡                              (                x                )                                                          f            ⁡                          (              x              )                                      }                    deg         less than         4            
The modular calculation gives
x10 modulo(1+x+x4)=1+x+x2
The mask polynomial that gives shift 10 at the PSN output for the loading 1000 is then calculated as       m    ⁢          (      x      )        =                    {                              1            +            x            +                          x              2                                            1            +            x            +                          x              4                                      }                    deg         less than         4              =          1      +              x        2            +              x        3            
which gives the mask vector (m0, m1, m2, m3)=(1, 0, 1, 1). This indicates that all but the second stage of the MSRG are modulo-2 added at the PSN to give the required shift at the PSN output, as shown in FIG. 7, numeral 700.
The application of the general procedure for the initial loading 1001 takes the following steps:
1. For the initial loading 1001, the initial state polynomial is s0(x)=1. From (9) the numerator polynomial gq(x) the reverse of s0(x), or gq(x)=1+x3=x14 modulo f(x), so that q=14.
2. From (11b), the mask parameter r=kxe2x88x92q+nxe2x88x92=10xe2x88x9214+4xe2x88x921=xe2x88x921+15=14, The required mask polynomial is calculated as       m    ⁡          (      x      )        =                    {                                            x                              r                ⁢                                  xe2x80x83                                ⁢                mod                ⁢                                  xe2x80x83                                ⁢                P                                      ⁢            mod            ⁢                          xe2x80x83                        ⁢                          f              ⁡                              (                x                )                                                          f            ⁡                          (              x              )                                      }                    deg         less than         n              =                  {                                            x              14                        ⁢            mod            ⁢                          xe2x80x83                        ⁢                          f              ⁡                              (                x                )                                                          f            ⁡                          (              x              )                                      }                    deg         less than         4            
where
g14(x)=14 modulo(1+x+x4)=1+x3
giving       m    ⁢          (      x      )        =                    {                              1            +                          x              3                                            1            +            x            +                          x              4                                      }                    deg         less than         4              =          1      +      x      +              x        2            
which gives the mask vector (m0, m1, m2, m3)=(1, 1, 1, 0). This indicates that all but the fourth stage of the MSRG are modulo-2 added at the PSN to give the required shift at the PSN output, as shown in FIG. 7.
The MSRG masks and corresponding PSNs for the two different initial loadings in this example are compared in FIG. 7, numeral 700. The MSRG mask formulas applied in these two situations have enabled us to produce the same shift (k=10) at the outputs of the PSNs (703 and 706), although the shifts at the outputs of the shift registers (701 and 704) are different.
The last two examples have demonstrated that, under the procedures disclosed in this invention, a specified phase shift of a PN sequence, relative to a reference sequence, can be obtained from the output of a PSN for either an SSRG or an MSRG under any nonzero initial loading of the respective LFSR.
As set forth above, the present invention discloses a method and program for determining the PN generator mask which is required to obtain a specific shift of the PN sequence at the output of a phase shift network (PSN), relative to a reference sequence, for either a simple shift register generator (SSRG) or a modular shift register generator (MSRG) under any nonzero initial loading of the respective n-stage linear feedback shift register (LFSR).
For an n-stage PN sequence generator which is implemented by using either an SSRG or an MSRG, the output for a given loading vector produces a PN sequence with a phase shift of q bits relative to the reference sequence 1/f(x) for each type of LFSR, where f(x) is the characteristic polynomial for the sequence. The computation for the mask vector for the present invention comprises the following steps:
(a) Find the value of q, the sequence phase shift at the PN generator output.
(b) Calculate the mask vector by first determining the value of a mask parameter, denoted r and given by the equation
Mask parameter=r=kxe2x88x92q+nxe2x88x921xe2x80x83xe2x80x83(12)
where the sequence at the PSN output is to be shifted by k bits from the reference sequence 1/f(x) using the mask, n being the number of shift register stages, and r is calculated modulo the period of the sequence, P=2nxe2x88x921.
(b1) For the SSRG type of LFSR, as diagrammed in FIG. 8 (numeral 800), using the value of r, calculate the mask vector as the coefficients (m0, m1, . . . , mnxe2x88x921) of the mask polynomial m(x)=m0+m1x+ . . . +mnxe2x88x92xnxe2x88x921 given by
Mask polynomial=m(x)=gr(x)=xr modulo f(x)xe2x80x83xe2x80x83(13a)
(b2) For the MSRG type of LFSR, as diagrammed in FIG. 9 (numeral 900), using the value of r, calculate the mask vector as the coefficients (m0, m1, . . . , mnxe2x88x921) of the mask polynomial m(x)=m0+m1x+ . . . +mnxe2x88x921xnxe2x88x921 given by                                                                         Mask                ⁢                                  xe2x80x83                                ⁢                polynomial                            =                                                m                  ⁡                                      (                    x                    )                                                  =                                                      terms                    ⁢                                          xe2x80x83                                        ⁢                    of                    ⁢                                          xe2x80x83                                        ⁢                                                                                            g                          r                                                ⁡                                                  (                          x                          )                                                                    /                                              f                        ⁡                                                  (                          x                          )                                                                                      ⁢                                          xe2x80x83                                        ⁢                    with                    ⁢                                          xe2x80x83                                        ⁢                    degree                                     less than                   n                                                                                                        =                                                terms                  ⁢                                      xe2x80x83                                    ⁢                                                            of                      ⁢                                              xe2x80x83                                            [                                                                        x                          r                                                ⁢                                                  xe2x80x83                                                ⁢                        mod                        ⁢                                                  xe2x80x83                                                ⁢                                                  f                          ⁡                                                      (                            x                            )                                                                                              ]                                        /                                          f                      ⁡                                              (                        x                        )                                                                              ⁢                                      xe2x80x83                                    ⁢                  with                  ⁢                                      xe2x80x83                                    ⁢                  degree                                 less than                 n                                                                        (13b)            
The method applies, for example, in a multi-cell code division multiple access (CDMA) system where the desired shift k for a given base station is a multiple of a PN code offset relative to a reference base station.